home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2008 February / PCWFEB08.iso / Software / Resources / Developers / XAMPP 1.5.4 / Windows installer / xampp-win32-1.5.4-installer.exe / xampp / php / pear / adodb / adodb-xmlschema.inc.php < prev    next >
Encoding:
PHP Script  |  2006-01-24  |  54.0 KB  |  2,221 lines
  1. <?php
  2. // Copyright (c) 2004 ars Cognita Inc., all rights reserved
  3. /* ******************************************************************************
  4.     Released under both BSD license and Lesser GPL library license. 
  5.      Whenever there is any discrepancy between the two licenses, 
  6.      the BSD license will take precedence. 
  7. *******************************************************************************/
  8. /**
  9.  * xmlschema is a class that allows the user to quickly and easily
  10.  * build a database on any ADOdb-supported platform using a simple
  11.  * XML schema.
  12.  *
  13.  * Last Editor: $Author: jlim $
  14.  * @author Richard Tango-Lowy & Dan Cech
  15.  * @version $Revision: 1.12 $
  16.  *
  17.  * @package axmls
  18.  * @tutorial getting_started.pkg
  19.  */
  20.  
  21. function _file_get_contents($file) 
  22. {
  23.      if (function_exists('file_get_contents')) return file_get_contents($file);
  24.     
  25.     $f = fopen($file,'r');
  26.     if (!$f) return '';
  27.     $t = '';
  28.     
  29.     while ($s = fread($f,100000)) $t .= $s;
  30.     fclose($f);
  31.     return $t;
  32. }
  33.  
  34.  
  35. /**
  36. * Debug on or off
  37. */
  38. if( !defined( 'XMLS_DEBUG' ) ) {
  39.     define( 'XMLS_DEBUG', FALSE );
  40. }
  41.  
  42. /**
  43. * Default prefix key
  44. */
  45. if( !defined( 'XMLS_PREFIX' ) ) {
  46.     define( 'XMLS_PREFIX', '%%P' );
  47. }
  48.  
  49. /**
  50. * Maximum length allowed for object prefix
  51. */
  52. if( !defined( 'XMLS_PREFIX_MAXLEN' ) ) {
  53.     define( 'XMLS_PREFIX_MAXLEN', 10 );
  54. }
  55.  
  56. /**
  57. * Execute SQL inline as it is generated
  58. */
  59. if( !defined( 'XMLS_EXECUTE_INLINE' ) ) {
  60.     define( 'XMLS_EXECUTE_INLINE', FALSE );
  61. }
  62.  
  63. /**
  64. * Continue SQL Execution if an error occurs?
  65. */
  66. if( !defined( 'XMLS_CONTINUE_ON_ERROR' ) ) {
  67.     define( 'XMLS_CONTINUE_ON_ERROR', FALSE );
  68. }
  69.  
  70. /**
  71. * Current Schema Version
  72. */
  73. if( !defined( 'XMLS_SCHEMA_VERSION' ) ) {
  74.     define( 'XMLS_SCHEMA_VERSION', '0.2' );
  75. }
  76.  
  77. /**
  78. * Default Schema Version.  Used for Schemas without an explicit version set.
  79. */
  80. if( !defined( 'XMLS_DEFAULT_SCHEMA_VERSION' ) ) {
  81.     define( 'XMLS_DEFAULT_SCHEMA_VERSION', '0.1' );
  82. }
  83.  
  84. /**
  85. * Default Schema Version.  Used for Schemas without an explicit version set.
  86. */
  87. if( !defined( 'XMLS_DEFAULT_UPGRADE_METHOD' ) ) {
  88.     define( 'XMLS_DEFAULT_UPGRADE_METHOD', 'ALTER' );
  89. }
  90.  
  91. /**
  92. * Include the main ADODB library
  93. */
  94. if( !defined( '_ADODB_LAYER' ) ) {
  95.     require( 'adodb.inc.php' );
  96.     require( 'adodb-datadict.inc.php' );
  97. }
  98.  
  99. /**
  100. * Abstract DB Object. This class provides basic methods for database objects, such
  101. * as tables and indexes.
  102. *
  103. * @package axmls
  104. * @access private
  105. */
  106. class dbObject {
  107.     
  108.     /**
  109.     * var object Parent
  110.     */
  111.     var $parent;
  112.     
  113.     /**
  114.     * var string current element
  115.     */
  116.     var $currentElement;
  117.     
  118.     /**
  119.     * NOP
  120.     */
  121.     function dbObject( &$parent, $attributes = NULL ) {
  122.         $this->parent =& $parent;
  123.     }
  124.     
  125.     /**
  126.     * XML Callback to process start elements
  127.     *
  128.     * @access private
  129.     */
  130.     function _tag_open( &$parser, $tag, $attributes ) {
  131.         
  132.     }
  133.     
  134.     /**
  135.     * XML Callback to process CDATA elements
  136.     *
  137.     * @access private
  138.     */
  139.     function _tag_cdata( &$parser, $cdata ) {
  140.         
  141.     }
  142.     
  143.     /**
  144.     * XML Callback to process end elements
  145.     *
  146.     * @access private
  147.     */
  148.     function _tag_close( &$parser, $tag ) {
  149.         
  150.     }
  151.     
  152.     function create() {
  153.         return array();
  154.     }
  155.     
  156.     /**
  157.     * Destroys the object
  158.     */
  159.     function destroy() {
  160.         unset( $this );
  161.     }
  162.     
  163.     /**
  164.     * Checks whether the specified RDBMS is supported by the current
  165.     * database object or its ranking ancestor.
  166.     *
  167.     * @param string $platform RDBMS platform name (from ADODB platform list).
  168.     * @return boolean TRUE if RDBMS is supported; otherwise returns FALSE.
  169.     */
  170.     function supportedPlatform( $platform = NULL ) {
  171.         return is_object( $this->parent ) ? $this->parent->supportedPlatform( $platform ) : TRUE;
  172.     }
  173.     
  174.     /**
  175.     * Returns the prefix set by the ranking ancestor of the database object.
  176.     *
  177.     * @param string $name Prefix string.
  178.     * @return string Prefix.
  179.     */
  180.     function prefix( $name = '' ) {
  181.         return is_object( $this->parent ) ? $this->parent->prefix( $name ) : $name;
  182.     }
  183.     
  184.     /**
  185.     * Extracts a field ID from the specified field.
  186.     *
  187.     * @param string $field Field.
  188.     * @return string Field ID.
  189.     */
  190.     function FieldID( $field ) {
  191.         return strtoupper( preg_replace( '/^`(.+)`$/', '$1', $field ) );
  192.     }
  193. }
  194.  
  195. /**
  196. * Creates a table object in ADOdb's datadict format
  197. *
  198. * This class stores information about a database table. As charactaristics
  199. * of the table are loaded from the external source, methods and properties
  200. * of this class are used to build up the table description in ADOdb's
  201. * datadict format.
  202. *
  203. * @package axmls
  204. * @access private
  205. */
  206. class dbTable extends dbObject {
  207.     
  208.     /**
  209.     * @var string Table name
  210.     */
  211.     var $name;
  212.     
  213.     /**
  214.     * @var array Field specifier: Meta-information about each field
  215.     */
  216.     var $fields = array();
  217.     
  218.     /**
  219.     * @var array List of table indexes.
  220.     */
  221.     var $indexes = array();
  222.     
  223.     /**
  224.     * @var array Table options: Table-level options
  225.     */
  226.     var $opts = array();
  227.     
  228.     /**
  229.     * @var string Field index: Keeps track of which field is currently being processed
  230.     */
  231.     var $current_field;
  232.     
  233.     /**
  234.     * @var boolean Mark table for destruction
  235.     * @access private
  236.     */
  237.     var $drop_table;
  238.     
  239.     /**
  240.     * @var boolean Mark field for destruction (not yet implemented)
  241.     * @access private
  242.     */
  243.     var $drop_field = array();
  244.     
  245.     /**
  246.     * Iniitializes a new table object.
  247.     *
  248.     * @param string $prefix DB Object prefix
  249.     * @param array $attributes Array of table attributes.
  250.     */
  251.     function dbTable( &$parent, $attributes = NULL ) {
  252.         $this->parent =& $parent;
  253.         $this->name = $this->prefix($attributes['NAME']);
  254.     }
  255.     
  256.     /**
  257.     * XML Callback to process start elements. Elements currently 
  258.     * processed are: INDEX, DROP, FIELD, KEY, NOTNULL, AUTOINCREMENT & DEFAULT. 
  259.     *
  260.     * @access private
  261.     */
  262.     function _tag_open( &$parser, $tag, $attributes ) {
  263.         $this->currentElement = strtoupper( $tag );
  264.         
  265.         switch( $this->currentElement ) {
  266.             case 'INDEX':
  267.                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
  268.                     xml_set_object( $parser, $this->addIndex( $attributes ) );
  269.                 }
  270.                 break;
  271.             case 'DATA':
  272.                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
  273.                     xml_set_object( $parser, $this->addData( $attributes ) );
  274.                 }
  275.                 break;
  276.             case 'DROP':
  277.                 $this->drop();
  278.                 break;
  279.             case 'FIELD':
  280.                 // Add a field
  281.                 $fieldName = $attributes['NAME'];
  282.                 $fieldType = $attributes['TYPE'];
  283.                 $fieldSize = isset( $attributes['SIZE'] ) ? $attributes['SIZE'] : NULL;
  284.                 $fieldOpts = isset( $attributes['OPTS'] ) ? $attributes['OPTS'] : NULL;
  285.                 
  286.                 $this->addField( $fieldName, $fieldType, $fieldSize, $fieldOpts );
  287.                 break;
  288.             case 'KEY':
  289.             case 'NOTNULL':
  290.             case 'AUTOINCREMENT':
  291.                 // Add a field option
  292.                 $this->addFieldOpt( $this->current_field, $this->currentElement );
  293.                 break;
  294.             case 'DEFAULT':
  295.                 // Add a field option to the table object
  296.                 
  297.                 // Work around ADOdb datadict issue that misinterprets empty strings.
  298.                 if( $attributes['VALUE'] == '' ) {
  299.                     $attributes['VALUE'] = " '' ";
  300.                 }
  301.                 
  302.                 $this->addFieldOpt( $this->current_field, $this->currentElement, $attributes['VALUE'] );
  303.                 break;
  304.             case 'DEFDATE':
  305.             case 'DEFTIMESTAMP':
  306.                 // Add a field option to the table object
  307.                 $this->addFieldOpt( $this->current_field, $this->currentElement );
  308.                 break;
  309.             default:
  310.                 // print_r( array( $tag, $attributes ) );
  311.         }
  312.     }
  313.     
  314.     /**
  315.     * XML Callback to process CDATA elements
  316.     *
  317.     * @access private
  318.     */
  319.     function _tag_cdata( &$parser, $cdata ) {
  320.         switch( $this->currentElement ) {
  321.             // Table constraint
  322.             case 'CONSTRAINT':
  323.                 if( isset( $this->current_field ) ) {
  324.                     $this->addFieldOpt( $this->current_field, $this->currentElement, $cdata );
  325.                 } else {
  326.                     $this->addTableOpt( $cdata );
  327.                 }
  328.                 break;
  329.             // Table option
  330.             case 'OPT':
  331.                 $this->addTableOpt( $cdata );
  332.                 break;
  333.             default:
  334.                 
  335.         }
  336.     }
  337.     
  338.     /**
  339.     * XML Callback to process end elements
  340.     *
  341.     * @access private
  342.     */
  343.     function _tag_close( &$parser, $tag ) {
  344.         $this->currentElement = '';
  345.         
  346.         switch( strtoupper( $tag ) ) {
  347.             case 'TABLE':
  348.                 $this->parent->addSQL( $this->create( $this->parent ) );
  349.                 xml_set_object( $parser, $this->parent );
  350.                 $this->destroy();
  351.                 break;
  352.             case 'FIELD':
  353.                 unset($this->current_field);
  354.                 break;
  355.  
  356.         }
  357.     }
  358.     
  359.     /**
  360.     * Adds an index to a table object
  361.     *
  362.     * @param array $attributes Index attributes
  363.     * @return object dbIndex object
  364.     */
  365.     function &addIndex( $attributes ) {
  366.         $name = strtoupper( $attributes['NAME'] );
  367.         $this->indexes[$name] =& new dbIndex( $this, $attributes );
  368.         return $this->indexes[$name];
  369.     }
  370.     
  371.     /**
  372.     * Adds data to a table object
  373.     *
  374.     * @param array $attributes Data attributes
  375.     * @return object dbData object
  376.     */
  377.     function &addData( $attributes ) {
  378.         if( !isset( $this->data ) ) {
  379.             $this->data =& new dbData( $this, $attributes );
  380.         }
  381.         return $this->data;
  382.     }
  383.     
  384.     /**
  385.     * Adds a field to a table object
  386.     *
  387.     * $name is the name of the table to which the field should be added. 
  388.     * $type is an ADODB datadict field type. The following field types
  389.     * are supported as of ADODB 3.40:
  390.     *     - C:  varchar
  391.     *    - X:  CLOB (character large object) or largest varchar size
  392.     *       if CLOB is not supported
  393.     *    - C2: Multibyte varchar
  394.     *    - X2: Multibyte CLOB
  395.     *    - B:  BLOB (binary large object)
  396.     *    - D:  Date (some databases do not support this, and we return a datetime type)
  397.     *    - T:  Datetime or Timestamp
  398.     *    - L:  Integer field suitable for storing booleans (0 or 1)
  399.     *    - I:  Integer (mapped to I4)
  400.     *    - I1: 1-byte integer
  401.     *    - I2: 2-byte integer
  402.     *    - I4: 4-byte integer
  403.     *    - I8: 8-byte integer
  404.     *    - F:  Floating point number
  405.     *    - N:  Numeric or decimal number
  406.     *
  407.     * @param string $name Name of the table to which the field will be added.
  408.     * @param string $type    ADODB datadict field type.
  409.     * @param string $size    Field size
  410.     * @param array $opts    Field options array
  411.     * @return array Field specifier array
  412.     */
  413.     function addField( $name, $type, $size = NULL, $opts = NULL ) {
  414.         $field_id = $this->FieldID( $name );
  415.         
  416.         // Set the field index so we know where we are
  417.         $this->current_field = $field_id;
  418.         
  419.         // Set the field name (required)
  420.         $this->fields[$field_id]['NAME'] = $name;
  421.         
  422.         // Set the field type (required)
  423.         $this->fields[$field_id]['TYPE'] = $type;
  424.         
  425.         // Set the field size (optional)
  426.         if( isset( $size ) ) {
  427.             $this->fields[$field_id]['SIZE'] = $size;
  428.         }
  429.         
  430.         // Set the field options
  431.         if( isset( $opts ) ) {
  432.             $this->fields[$field_id]['OPTS'][] = $opts;
  433.         }
  434.     }
  435.     
  436.     /**
  437.     * Adds a field option to the current field specifier
  438.     *
  439.     * This method adds a field option allowed by the ADOdb datadict 
  440.     * and appends it to the given field.
  441.     *
  442.     * @param string $field    Field name
  443.     * @param string $opt ADOdb field option
  444.     * @param mixed $value Field option value
  445.     * @return array Field specifier array
  446.     */
  447.     function addFieldOpt( $field, $opt, $value = NULL ) {
  448.         if( !isset( $value ) ) {
  449.             $this->fields[$this->FieldID( $field )]['OPTS'][] = $opt;
  450.         // Add the option and value
  451.         } else {
  452.             $this->fields[$this->FieldID( $field )]['OPTS'][] = array( $opt => $value );
  453.         }
  454.     }
  455.     
  456.     /**
  457.     * Adds an option to the table
  458.     *
  459.     * This method takes a comma-separated list of table-level options
  460.     * and appends them to the table object.
  461.     *
  462.     * @param string $opt Table option
  463.     * @return array Options
  464.     */
  465.     function addTableOpt( $opt ) {
  466.         $this->opts[] = $opt;
  467.         
  468.         return $this->opts;
  469.     }
  470.     
  471.     /**
  472.     * Generates the SQL that will create the table in the database
  473.     *
  474.     * @param object $xmls adoSchema object
  475.     * @return array Array containing table creation SQL
  476.     */
  477.     function create( &$xmls ) {
  478.         $sql = array();
  479.         
  480.         // drop any existing indexes
  481.         if( is_array( $legacy_indexes = $xmls->dict->MetaIndexes( $this->name ) ) ) {
  482.             foreach( $legacy_indexes as $index => $index_details ) {
  483.                 $sql[] = $xmls->dict->DropIndexSQL( $index, $this->name );
  484.             }
  485.         }
  486.         
  487.         // remove fields to be dropped from table object
  488.         foreach( $this->drop_field as $field ) {
  489.             unset( $this->fields[$field] );
  490.         }
  491.         
  492.         // if table exists
  493.         if( is_array( $legacy_fields = $xmls->dict->MetaColumns( $this->name ) ) ) {
  494.             // drop table
  495.             if( $this->drop_table ) {
  496.                 $sql[] = $xmls->dict->DropTableSQL( $this->name );
  497.                 
  498.                 return $sql;
  499.             }
  500.             
  501.             // drop any existing fields not in schema
  502.             foreach( $legacy_fields as $field_id => $field ) {
  503.                 if( !isset( $this->fields[$field_id] ) ) {
  504.                     $sql[] = $xmls->dict->DropColumnSQL( $this->name, '`'.$field->name.'`' );
  505.                 }
  506.             }
  507.         // if table doesn't exist
  508.         } else {
  509.             if( $this->drop_table ) {
  510.                 return $sql;
  511.             }
  512.             
  513.             $legacy_fields = array();
  514.         }
  515.         
  516.         // Loop through the field specifier array, building the associative array for the field options
  517.         $fldarray = array();
  518.         
  519.         foreach( $this->fields as $field_id => $finfo ) {
  520.             // Set an empty size if it isn't supplied
  521.             if( !isset( $finfo['SIZE'] ) ) {
  522.                 $finfo['SIZE'] = '';
  523.             }
  524.             
  525.             // Initialize the field array with the type and size
  526.             $fldarray[$field_id] = array(
  527.                 'NAME' => $finfo['NAME'],
  528.                 'TYPE' => $finfo['TYPE'],
  529.                 'SIZE' => $finfo['SIZE']
  530.             );
  531.             
  532.             // Loop through the options array and add the field options. 
  533.             if( isset( $finfo['OPTS'] ) ) {
  534.                 foreach( $finfo['OPTS'] as $opt ) {
  535.                     // Option has an argument.
  536.                     if( is_array( $opt ) ) {
  537.                         $key = key( $opt );
  538.                         $value = $opt[key( $opt )];
  539.                         @$fldarray[$field_id][$key] .= $value;
  540.                     // Option doesn't have arguments
  541.                     } else {
  542.                         $fldarray[$field_id][$opt] = $opt;
  543.                     }
  544.                 }
  545.             }
  546.         }
  547.         
  548.         if( empty( $legacy_fields ) ) {
  549.             // Create the new table
  550.             $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
  551.             logMsg( end( $sql ), 'Generated CreateTableSQL' );
  552.         } else {
  553.             // Upgrade an existing table
  554.             logMsg( "Upgrading {$this->name} using '{$xmls->upgrade}'" );
  555.             switch( $xmls->upgrade ) {
  556.                 // Use ChangeTableSQL
  557.                 case 'ALTER':
  558.                     logMsg( 'Generated ChangeTableSQL (ALTERing table)' );
  559.                     $sql[] = $xmls->dict->ChangeTableSQL( $this->name, $fldarray, $this->opts );
  560.                     break;
  561.                 case 'REPLACE':
  562.                     logMsg( 'Doing upgrade REPLACE (testing)' );
  563.                     $sql[] = $xmls->dict->DropTableSQL( $this->name );
  564.                     $sql[] = $xmls->dict->CreateTableSQL( $this->name, $fldarray, $this->opts );
  565.                     break;
  566.                 // ignore table
  567.                 default:
  568.                     return array();
  569.             }
  570.         }
  571.         
  572.         foreach( $this->indexes as $index ) {
  573.             $sql[] = $index->create( $xmls );
  574.         }
  575.         
  576.         if( isset( $this->data ) ) {
  577.             $sql[] = $this->data->create( $xmls );
  578.         }
  579.         
  580.         return $sql;
  581.     }
  582.     
  583.     /**
  584.     * Marks a field or table for destruction
  585.     */
  586.     function drop() {
  587.         if( isset( $this->current_field ) ) {
  588.             // Drop the current field
  589.             logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
  590.             // $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
  591.             $this->drop_field[$this->current_field] = $this->current_field;
  592.         } else {
  593.             // Drop the current table
  594.             logMsg( "Dropping table '{$this->name}'" );
  595.             // $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
  596.             $this->drop_table = TRUE;
  597.         }
  598.     }
  599. }
  600.  
  601. /**
  602. * Creates an index object in ADOdb's datadict format
  603. *
  604. * This class stores information about a database index. As charactaristics
  605. * of the index are loaded from the external source, methods and properties
  606. * of this class are used to build up the index description in ADOdb's
  607. * datadict format.
  608. *
  609. * @package axmls
  610. * @access private
  611. */
  612. class dbIndex extends dbObject {
  613.     
  614.     /**
  615.     * @var string    Index name
  616.     */
  617.     var $name;
  618.     
  619.     /**
  620.     * @var array    Index options: Index-level options
  621.     */
  622.     var $opts = array();
  623.     
  624.     /**
  625.     * @var array    Indexed fields: Table columns included in this index
  626.     */
  627.     var $columns = array();
  628.     
  629.     /**
  630.     * @var boolean Mark index for destruction
  631.     * @access private
  632.     */
  633.     var $drop = FALSE;
  634.     
  635.     /**
  636.     * Initializes the new dbIndex object.
  637.     *
  638.     * @param object $parent Parent object
  639.     * @param array $attributes Attributes
  640.     *
  641.     * @internal
  642.     */
  643.     function dbIndex( &$parent, $attributes = NULL ) {
  644.         $this->parent =& $parent;
  645.         
  646.         $this->name = $this->prefix ($attributes['NAME']);
  647.     }
  648.     
  649.     /**
  650.     * XML Callback to process start elements
  651.     *
  652.     * Processes XML opening tags. 
  653.     * Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH. 
  654.     *
  655.     * @access private
  656.     */
  657.     function _tag_open( &$parser, $tag, $attributes ) {
  658.         $this->currentElement = strtoupper( $tag );
  659.         
  660.         switch( $this->currentElement ) {
  661.             case 'DROP':
  662.                 $this->drop();
  663.                 break;
  664.             case 'CLUSTERED':
  665.             case 'BITMAP':
  666.             case 'UNIQUE':
  667.             case 'FULLTEXT':
  668.             case 'HASH':
  669.                 // Add index Option
  670.                 $this->addIndexOpt( $this->currentElement );
  671.                 break;
  672.             default:
  673.                 // print_r( array( $tag, $attributes ) );
  674.         }
  675.     }
  676.     
  677.     /**
  678.     * XML Callback to process CDATA elements
  679.     *
  680.     * Processes XML cdata.
  681.     *
  682.     * @access private
  683.     */
  684.     function _tag_cdata( &$parser, $cdata ) {
  685.         switch( $this->currentElement ) {
  686.             // Index field name
  687.             case 'COL':
  688.                 $this->addField( $cdata );
  689.                 break;
  690.             default:
  691.                 
  692.         }
  693.     }
  694.     
  695.     /**
  696.     * XML Callback to process end elements
  697.     *
  698.     * @access private
  699.     */
  700.     function _tag_close( &$parser, $tag ) {
  701.         $this->currentElement = '';
  702.         
  703.         switch( strtoupper( $tag ) ) {
  704.             case 'INDEX':
  705.                 xml_set_object( $parser, $this->parent );
  706.                 break;
  707.         }
  708.     }
  709.     
  710.     /**
  711.     * Adds a field to the index
  712.     *
  713.     * @param string $name Field name
  714.     * @return string Field list
  715.     */
  716.     function addField( $name ) {
  717.         $this->columns[$this->FieldID( $name )] = $name;
  718.         
  719.         // Return the field list
  720.         return $this->columns;
  721.     }
  722.     
  723.     /**
  724.     * Adds options to the index
  725.     *
  726.     * @param string $opt Comma-separated list of index options.
  727.     * @return string Option list
  728.     */
  729.     function addIndexOpt( $opt ) {
  730.         $this->opts[] = $opt;
  731.         
  732.         // Return the options list
  733.         return $this->opts;
  734.     }
  735.     
  736.     /**
  737.     * Generates the SQL that will create the index in the database
  738.     *
  739.     * @param object $xmls adoSchema object
  740.     * @return array Array containing index creation SQL
  741.     */
  742.     function create( &$xmls ) {
  743.         if( $this->drop ) {
  744.             return NULL;
  745.         }
  746.         
  747.         // eliminate any columns that aren't in the table
  748.         foreach( $this->columns as $id => $col ) {
  749.             if( !isset( $this->parent->fields[$id] ) ) {
  750.                 unset( $this->columns[$id] );
  751.             }
  752.         }
  753.         
  754.         return $xmls->dict->CreateIndexSQL( $this->name, $this->parent->name, $this->columns, $this->opts );
  755.     }
  756.     
  757.     /**
  758.     * Marks an index for destruction
  759.     */
  760.     function drop() {
  761.         $this->drop = TRUE;
  762.     }
  763. }
  764.  
  765. /**
  766. * Creates a data object in ADOdb's datadict format
  767. *
  768. * This class stores information about table data.
  769. *
  770. * @package axmls
  771. * @access private
  772. */
  773. class dbData extends dbObject {
  774.     
  775.     var $data = array();
  776.     
  777.     var $row;
  778.     
  779.     /**
  780.     * Initializes the new dbIndex object.
  781.     *
  782.     * @param object $parent Parent object
  783.     * @param array $attributes Attributes
  784.     *
  785.     * @internal
  786.     */
  787.     function dbData( &$parent, $attributes = NULL ) {
  788.         $this->parent =& $parent;
  789.     }
  790.     
  791.     /**
  792.     * XML Callback to process start elements
  793.     *
  794.     * Processes XML opening tags. 
  795.     * Elements currently processed are: DROP, CLUSTERED, BITMAP, UNIQUE, FULLTEXT & HASH. 
  796.     *
  797.     * @access private
  798.     */
  799.     function _tag_open( &$parser, $tag, $attributes ) {
  800.         $this->currentElement = strtoupper( $tag );
  801.         
  802.         switch( $this->currentElement ) {
  803.             case 'ROW':
  804.                 $this->row = count( $this->data );
  805.                 $this->data[$this->row] = array();
  806.                 break;
  807.             case 'F':
  808.                 $this->addField($attributes);
  809.             default:
  810.                 // print_r( array( $tag, $attributes ) );
  811.         }
  812.     }
  813.     
  814.     /**
  815.     * XML Callback to process CDATA elements
  816.     *
  817.     * Processes XML cdata.
  818.     *
  819.     * @access private
  820.     */
  821.     function _tag_cdata( &$parser, $cdata ) {
  822.         switch( $this->currentElement ) {
  823.             // Index field name
  824.             case 'F':
  825.                 $this->addData( $cdata );
  826.                 break;
  827.             default:
  828.                 
  829.         }
  830.     }
  831.     
  832.     /**
  833.     * XML Callback to process end elements
  834.     *
  835.     * @access private
  836.     */
  837.     function _tag_close( &$parser, $tag ) {
  838.         $this->currentElement = '';
  839.         
  840.         switch( strtoupper( $tag ) ) {
  841.             case 'DATA':
  842.                 xml_set_object( $parser, $this->parent );
  843.                 break;
  844.         }
  845.     }
  846.     
  847.     /**
  848.     * Adds a field to the index
  849.     *
  850.     * @param string $name Field name
  851.     * @return string Field list
  852.     */
  853.     function addField( $attributes ) {
  854.         if( isset( $attributes['NAME'] ) ) {
  855.             $name = $attributes['NAME'];
  856.         } else {
  857.             $name = count($this->data[$this->row]);
  858.         }
  859.         
  860.         // Set the field index so we know where we are
  861.         $this->current_field = $this->FieldID( $name );
  862.     }
  863.     
  864.     /**
  865.     * Adds options to the index
  866.     *
  867.     * @param string $opt Comma-separated list of index options.
  868.     * @return string Option list
  869.     */
  870.     function addData( $cdata ) {
  871.         if( !isset( $this->data[$this->row] ) ) {
  872.             $this->data[$this->row] = array();
  873.         }
  874.         
  875.         if( !isset( $this->data[$this->row][$this->current_field] ) ) {
  876.             $this->data[$this->row][$this->current_field] = '';
  877.         }
  878.         
  879.         $this->data[$this->row][$this->current_field] .= $cdata;
  880.     }
  881.     
  882.     /**
  883.     * Generates the SQL that will create the index in the database
  884.     *
  885.     * @param object $xmls adoSchema object
  886.     * @return array Array containing index creation SQL
  887.     */
  888.     function create( &$xmls ) {
  889.         $table = $xmls->dict->TableName($this->parent->name);
  890.         $table_field_count = count($this->parent->fields);
  891.         $sql = array();
  892.         
  893.         // eliminate any columns that aren't in the table
  894.         foreach( $this->data as $row ) {
  895.             $table_fields = $this->parent->fields;
  896.             $fields = array();
  897.             
  898.             foreach( $row as $field_id => $field_data ) {
  899.                 if( !array_key_exists( $field_id, $table_fields ) ) {
  900.                     if( is_numeric( $field_id ) ) {
  901.                         $field_id = reset( array_keys( $table_fields ) );
  902.                     } else {
  903.                         continue;
  904.                     }
  905.                 }
  906.                 
  907.                 $name = $table_fields[$field_id]['NAME'];
  908.                 
  909.                 switch( $table_fields[$field_id]['TYPE'] ) {
  910.                     case 'C':
  911.                     case 'C2':
  912.                     case 'X':
  913.                     case 'X2':
  914.                         $fields[$name] = $xmls->db->qstr( $field_data );
  915.                         break;
  916.                     case 'I':
  917.                     case 'I1':
  918.                     case 'I2':
  919.                     case 'I4':
  920.                     case 'I8':
  921.                         $fields[$name] = intval($field_data);
  922.                         break;
  923.                     default:
  924.                         $fields[$name] = $field_data;
  925.                 }
  926.                 
  927.                 unset($table_fields[$field_id]);
  928.             }
  929.             
  930.             // check that at least 1 column is specified
  931.             if( empty( $fields ) ) {
  932.                 continue;
  933.             }
  934.             
  935.             // check that no required columns are missing
  936.             if( count( $fields ) < $table_field_count ) {
  937.                 foreach( $table_fields as $field ) {
  938.                     if (isset( $field['OPTS'] ))
  939.                         if( ( in_array( 'NOTNULL', $field['OPTS'] ) || in_array( 'KEY', $field['OPTS'] ) ) && !in_array( 'AUTOINCREMENT', $field['OPTS'] ) ) {
  940.                             continue(2);
  941.                         }
  942.                 }
  943.             }
  944.             
  945.             $sql[] = 'INSERT INTO '. $table .' ('. implode( ',', array_keys( $fields ) ) .') VALUES ('. implode( ',', $fields ) .')';
  946.         }
  947.         
  948.         return $sql;
  949.     }
  950. }
  951.  
  952. /**
  953. * Creates the SQL to execute a list of provided SQL queries
  954. *
  955. * @package axmls
  956. * @access private
  957. */
  958. class dbQuerySet extends dbObject {
  959.     
  960.     /**
  961.     * @var array    List of SQL queries
  962.     */
  963.     var $queries = array();
  964.     
  965.     /**
  966.     * @var string    String used to build of a query line by line
  967.     */
  968.     var $query;
  969.     
  970.     /**
  971.     * @var string    Query prefix key
  972.     */
  973.     var $prefixKey = '';
  974.     
  975.     /**
  976.     * @var boolean    Auto prefix enable (TRUE)
  977.     */
  978.     var $prefixMethod = 'AUTO';
  979.     
  980.     /**
  981.     * Initializes the query set.
  982.     *
  983.     * @param object $parent Parent object
  984.     * @param array $attributes Attributes
  985.     */
  986.     function dbQuerySet( &$parent, $attributes = NULL ) {
  987.         $this->parent =& $parent;
  988.             
  989.         // Overrides the manual prefix key
  990.         if( isset( $attributes['KEY'] ) ) {
  991.             $this->prefixKey = $attributes['KEY'];
  992.         }
  993.         
  994.         $prefixMethod = isset( $attributes['PREFIXMETHOD'] ) ? strtoupper( trim( $attributes['PREFIXMETHOD'] ) ) : '';
  995.         
  996.         // Enables or disables automatic prefix prepending
  997.         switch( $prefixMethod ) {
  998.             case 'AUTO':
  999.                 $this->prefixMethod = 'AUTO';
  1000.                 break;
  1001.             case 'MANUAL':
  1002.                 $this->prefixMethod = 'MANUAL';
  1003.                 break;
  1004.             case 'NONE':
  1005.                 $this->prefixMethod = 'NONE';
  1006.                 break;
  1007.         }
  1008.     }
  1009.     
  1010.     /**
  1011.     * XML Callback to process start elements. Elements currently 
  1012.     * processed are: QUERY. 
  1013.     *
  1014.     * @access private
  1015.     */
  1016.     function _tag_open( &$parser, $tag, $attributes ) {
  1017.         $this->currentElement = strtoupper( $tag );
  1018.         
  1019.         switch( $this->currentElement ) {
  1020.             case 'QUERY':
  1021.                 // Create a new query in a SQL queryset.
  1022.                 // Ignore this query set if a platform is specified and it's different than the 
  1023.                 // current connection platform.
  1024.                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
  1025.                     $this->newQuery();
  1026.                 } else {
  1027.                     $this->discardQuery();
  1028.                 }
  1029.                 break;
  1030.             default:
  1031.                 // print_r( array( $tag, $attributes ) );
  1032.         }
  1033.     }
  1034.     
  1035.     /**
  1036.     * XML Callback to process CDATA elements
  1037.     */
  1038.     function _tag_cdata( &$parser, $cdata ) {
  1039.         switch( $this->currentElement ) {
  1040.             // Line of queryset SQL data
  1041.             case 'QUERY':
  1042.                 $this->buildQuery( $cdata );
  1043.                 break;
  1044.             default:
  1045.                 
  1046.         }
  1047.     }
  1048.     
  1049.     /**
  1050.     * XML Callback to process end elements
  1051.     *
  1052.     * @access private
  1053.     */
  1054.     function _tag_close( &$parser, $tag ) {
  1055.         $this->currentElement = '';
  1056.         
  1057.         switch( strtoupper( $tag ) ) {
  1058.             case 'QUERY':
  1059.                 // Add the finished query to the open query set.
  1060.                 $this->addQuery();
  1061.                 break;
  1062.             case 'SQL':
  1063.                 $this->parent->addSQL( $this->create( $this->parent ) );
  1064.                 xml_set_object( $parser, $this->parent );
  1065.                 $this->destroy();
  1066.                 break;
  1067.             default:
  1068.                 
  1069.         }
  1070.     }
  1071.     
  1072.     /**
  1073.     * Re-initializes the query.
  1074.     *
  1075.     * @return boolean TRUE
  1076.     */
  1077.     function newQuery() {
  1078.         $this->query = '';
  1079.         
  1080.         return TRUE;
  1081.     }
  1082.     
  1083.     /**
  1084.     * Discards the existing query.
  1085.     *
  1086.     * @return boolean TRUE
  1087.     */
  1088.     function discardQuery() {
  1089.         unset( $this->query );
  1090.         
  1091.         return TRUE;
  1092.     }
  1093.     
  1094.     /** 
  1095.     * Appends a line to a query that is being built line by line
  1096.     *
  1097.     * @param string $data Line of SQL data or NULL to initialize a new query
  1098.     * @return string SQL query string.
  1099.     */
  1100.     function buildQuery( $sql = NULL ) {
  1101.         if( !isset( $this->query ) OR empty( $sql ) ) {
  1102.             return FALSE;
  1103.         }
  1104.         
  1105.         $this->query .= $sql;
  1106.         
  1107.         return $this->query;
  1108.     }
  1109.     
  1110.     /**
  1111.     * Adds a completed query to the query list
  1112.     *
  1113.     * @return string    SQL of added query
  1114.     */
  1115.     function addQuery() {
  1116.         if( !isset( $this->query ) ) {
  1117.             return FALSE;
  1118.         }
  1119.         
  1120.         $this->queries[] = $return = trim($this->query);
  1121.         
  1122.         unset( $this->query );
  1123.         
  1124.         return $return;
  1125.     }
  1126.     
  1127.     /**
  1128.     * Creates and returns the current query set
  1129.     *
  1130.     * @param object $xmls adoSchema object
  1131.     * @return array Query set
  1132.     */
  1133.     function create( &$xmls ) {
  1134.         foreach( $this->queries as $id => $query ) {
  1135.             switch( $this->prefixMethod ) {
  1136.                 case 'AUTO':
  1137.                     // Enable auto prefix replacement
  1138.                     
  1139.                     // Process object prefix.
  1140.                     // Evaluate SQL statements to prepend prefix to objects
  1141.                     $query = $this->prefixQuery( '/^\s*((?is)INSERT\s+(INTO\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
  1142.                     $query = $this->prefixQuery( '/^\s*((?is)UPDATE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
  1143.                     $query = $this->prefixQuery( '/^\s*((?is)DELETE\s+(FROM\s+)?)((\w+\s*,?\s*)+)(\s.*$)/', $query, $xmls->objectPrefix );
  1144.                     
  1145.                     // SELECT statements aren't working yet
  1146.                     #$data = preg_replace( '/(?ias)(^\s*SELECT\s+.*\s+FROM)\s+(\W\s*,?\s*)+((?i)\s+WHERE.*$)/', "\1 $prefix\2 \3", $data );
  1147.                     
  1148.                 case 'MANUAL':
  1149.                     // If prefixKey is set and has a value then we use it to override the default constant XMLS_PREFIX.
  1150.                     // If prefixKey is not set, we use the default constant XMLS_PREFIX
  1151.                     if( isset( $this->prefixKey ) AND( $this->prefixKey !== '' ) ) {
  1152.                         // Enable prefix override
  1153.                         $query = str_replace( $this->prefixKey, $xmls->objectPrefix, $query );
  1154.                     } else {
  1155.                         // Use default replacement
  1156.                         $query = str_replace( XMLS_PREFIX , $xmls->objectPrefix, $query );
  1157.                     }
  1158.             }
  1159.             
  1160.             $this->queries[$id] = trim( $query );
  1161.         }
  1162.         
  1163.         // Return the query set array
  1164.         return $this->queries;
  1165.     }
  1166.     
  1167.     /**
  1168.     * Rebuilds the query with the prefix attached to any objects
  1169.     *
  1170.     * @param string $regex Regex used to add prefix
  1171.     * @param string $query SQL query string
  1172.     * @param string $prefix Prefix to be appended to tables, indices, etc.
  1173.     * @return string Prefixed SQL query string.
  1174.     */
  1175.     function prefixQuery( $regex, $query, $prefix = NULL ) {
  1176.         if( !isset( $prefix ) ) {
  1177.             return $query;
  1178.         }
  1179.         
  1180.         if( preg_match( $regex, $query, $match ) ) {
  1181.             $preamble = $match[1];
  1182.             $postamble = $match[5];
  1183.             $objectList = explode( ',', $match[3] );
  1184.             // $prefix = $prefix . '_';
  1185.             
  1186.             $prefixedList = '';
  1187.             
  1188.             foreach( $objectList as $object ) {
  1189.                 if( $prefixedList !== '' ) {
  1190.                     $prefixedList .= ', ';
  1191.                 }
  1192.                 
  1193.                 $prefixedList .= $prefix . trim( $object );
  1194.             }
  1195.             
  1196.             $query = $preamble . ' ' . $prefixedList . ' ' . $postamble;
  1197.         }
  1198.         
  1199.         return $query;
  1200.     }
  1201. }
  1202.  
  1203. /**
  1204. * Loads and parses an XML file, creating an array of "ready-to-run" SQL statements
  1205. * 
  1206. * This class is used to load and parse the XML file, to create an array of SQL statements
  1207. * that can be used to build a database, and to build the database using the SQL array.
  1208. *
  1209. * @tutorial getting_started.pkg
  1210. *
  1211. * @author Richard Tango-Lowy & Dan Cech
  1212. * @version $Revision: 1.12 $
  1213. *
  1214. * @package axmls
  1215. */
  1216. class adoSchema {
  1217.     
  1218.     /**
  1219.     * @var array    Array containing SQL queries to generate all objects
  1220.     * @access private
  1221.     */
  1222.     var $sqlArray;
  1223.     
  1224.     /**
  1225.     * @var object    ADOdb connection object
  1226.     * @access private
  1227.     */
  1228.     var $db;
  1229.     
  1230.     /**
  1231.     * @var object    ADOdb Data Dictionary
  1232.     * @access private
  1233.     */
  1234.     var $dict;
  1235.     
  1236.     /**
  1237.     * @var string Current XML element
  1238.     * @access private
  1239.     */
  1240.     var $currentElement = '';
  1241.     
  1242.     /**
  1243.     * @var string If set (to 'ALTER' or 'REPLACE'), upgrade an existing database
  1244.     * @access private
  1245.     */
  1246.     var $upgrade = '';
  1247.     
  1248.     /**
  1249.     * @var string Optional object prefix
  1250.     * @access private
  1251.     */
  1252.     var $objectPrefix = '';
  1253.     
  1254.     /**
  1255.     * @var long    Original Magic Quotes Runtime value
  1256.     * @access private
  1257.     */
  1258.     var $mgq;
  1259.     
  1260.     /**
  1261.     * @var long    System debug
  1262.     * @access private
  1263.     */
  1264.     var $debug;
  1265.     
  1266.     /**
  1267.     * @var string Regular expression to find schema version
  1268.     * @access private
  1269.     */
  1270.     var $versionRegex = '/<schema.*?( version="([^"]*)")?.*?>/';
  1271.     
  1272.     /**
  1273.     * @var string Current schema version
  1274.     * @access private
  1275.     */
  1276.     var $schemaVersion;
  1277.     
  1278.     /**
  1279.     * @var int    Success of last Schema execution
  1280.     */
  1281.     var $success;
  1282.     
  1283.     /**
  1284.     * @var bool    Execute SQL inline as it is generated
  1285.     */
  1286.     var $executeInline;
  1287.     
  1288.     /**
  1289.     * @var bool    Continue SQL execution if errors occur
  1290.     */
  1291.     var $continueOnError;
  1292.     
  1293.     /**
  1294.     * Creates an adoSchema object
  1295.     *
  1296.     * Creating an adoSchema object is the first step in processing an XML schema.
  1297.     * The only parameter is an ADOdb database connection object, which must already
  1298.     * have been created.
  1299.     *
  1300.     * @param object $db ADOdb database connection object.
  1301.     */
  1302.     function adoSchema( &$db ) {
  1303.         // Initialize the environment
  1304.         $this->mgq = get_magic_quotes_runtime();
  1305.         set_magic_quotes_runtime(0);
  1306.         
  1307.         $this->db =& $db;
  1308.         $this->debug = $this->db->debug;
  1309.         $this->dict = NewDataDictionary( $this->db );
  1310.         $this->sqlArray = array();
  1311.         $this->schemaVersion = XMLS_SCHEMA_VERSION;
  1312.         $this->executeInline( XMLS_EXECUTE_INLINE );
  1313.         $this->continueOnError( XMLS_CONTINUE_ON_ERROR );
  1314.         $this->setUpgradeMethod();
  1315.     }
  1316.     
  1317.     /**
  1318.     * Sets the method to be used for upgrading an existing database
  1319.     *
  1320.     * Use this method to specify how existing database objects should be upgraded.
  1321.     * The method option can be set to ALTER, REPLACE, BEST, or NONE. ALTER attempts to
  1322.     * alter each database object directly, REPLACE attempts to rebuild each object
  1323.     * from scratch, BEST attempts to determine the best upgrade method for each
  1324.     * object, and NONE disables upgrading.
  1325.     *
  1326.     * This method is not yet used by AXMLS, but exists for backward compatibility.
  1327.     * The ALTER method is automatically assumed when the adoSchema object is
  1328.     * instantiated; other upgrade methods are not currently supported.
  1329.     *
  1330.     * @param string $method Upgrade method (ALTER|REPLACE|BEST|NONE)
  1331.     * @returns string Upgrade method used
  1332.     */
  1333.     function SetUpgradeMethod( $method = '' ) {
  1334.         if( !is_string( $method ) ) {
  1335.             return FALSE;
  1336.         }
  1337.         
  1338.         $method = strtoupper( $method );
  1339.         
  1340.         // Handle the upgrade methods
  1341.         switch( $method ) {
  1342.             case 'ALTER':
  1343.                 $this->upgrade = $method;
  1344.                 break;
  1345.             case 'REPLACE':
  1346.                 $this->upgrade = $method;
  1347.                 break;
  1348.             case 'BEST':
  1349.                 $this->upgrade = 'ALTER';
  1350.                 break;
  1351.             case 'NONE':
  1352.                 $this->upgrade = 'NONE';
  1353.                 break;
  1354.             default:
  1355.                 // Use default if no legitimate method is passed.
  1356.                 $this->upgrade = XMLS_DEFAULT_UPGRADE_METHOD;
  1357.         }
  1358.         
  1359.         return $this->upgrade;
  1360.     }
  1361.     
  1362.     /**
  1363.     * Enables/disables inline SQL execution.
  1364.     *
  1365.     * Call this method to enable or disable inline execution of the schema. If the mode is set to TRUE (inline execution),
  1366.     * AXMLS applies the SQL to the database immediately as each schema entity is parsed. If the mode
  1367.     * is set to FALSE (post execution), AXMLS parses the entire schema and you will need to call adoSchema::ExecuteSchema()
  1368.     * to apply the schema to the database.
  1369.     *
  1370.     * @param bool $mode execute
  1371.     * @return bool current execution mode
  1372.     *
  1373.     * @see ParseSchema(), ExecuteSchema()
  1374.     */
  1375.     function ExecuteInline( $mode = NULL ) {
  1376.         if( is_bool( $mode ) ) {
  1377.             $this->executeInline = $mode;
  1378.         }
  1379.         
  1380.         return $this->executeInline;
  1381.     }
  1382.     
  1383.     /**
  1384.     * Enables/disables SQL continue on error.
  1385.     *
  1386.     * Call this method to enable or disable continuation of SQL execution if an error occurs.
  1387.     * If the mode is set to TRUE (continue), AXMLS will continue to apply SQL to the database, even if an error occurs.
  1388.     * If the mode is set to FALSE (halt), AXMLS will halt execution of generated sql if an error occurs, though parsing
  1389.     * of the schema will continue.
  1390.     *
  1391.     * @param bool $mode execute
  1392.     * @return bool current continueOnError mode
  1393.     *
  1394.     * @see addSQL(), ExecuteSchema()
  1395.     */
  1396.     function ContinueOnError( $mode = NULL ) {
  1397.         if( is_bool( $mode ) ) {
  1398.             $this->continueOnError = $mode;
  1399.         }
  1400.         
  1401.         return $this->continueOnError;
  1402.     }
  1403.     
  1404.     /**
  1405.     * Loads an XML schema from a file and converts it to SQL.
  1406.     *
  1407.     * Call this method to load the specified schema (see the DTD for the proper format) from
  1408.     * the filesystem and generate the SQL necessary to create the database described. 
  1409.     * @see ParseSchemaString()
  1410.     *
  1411.     * @param string $file Name of XML schema file.
  1412.     * @param bool $returnSchema Return schema rather than parsing.
  1413.     * @return array Array of SQL queries, ready to execute
  1414.     */
  1415.     function ParseSchema( $filename, $returnSchema = FALSE ) {
  1416.         return $this->ParseSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
  1417.     }
  1418.     
  1419.     /**
  1420.     * Loads an XML schema from a file and converts it to SQL.
  1421.     *
  1422.     * Call this method to load the specified schema from a file (see the DTD for the proper format) 
  1423.     * and generate the SQL necessary to create the database described by the schema.
  1424.     *
  1425.     * @param string $file Name of XML schema file.
  1426.     * @param bool $returnSchema Return schema rather than parsing.
  1427.     * @return array Array of SQL queries, ready to execute.
  1428.     *
  1429.     * @deprecated Replaced by adoSchema::ParseSchema() and adoSchema::ParseSchemaString()
  1430.     * @see ParseSchema(), ParseSchemaString()
  1431.     */
  1432.     function ParseSchemaFile( $filename, $returnSchema = FALSE ) {
  1433.         // Open the file
  1434.         if( !($fp = fopen( $filename, 'r' )) ) {
  1435.             // die( 'Unable to open file' );
  1436.             return FALSE;
  1437.         }
  1438.         
  1439.         // do version detection here
  1440.         if( $this->SchemaFileVersion( $filename ) != $this->schemaVersion ) {
  1441.             return FALSE;
  1442.         }
  1443.         
  1444.         if ( $returnSchema )
  1445.         {
  1446.             $xmlstring = '';
  1447.             while( $data = fread( $fp, 100000 ) ) {
  1448.                 $xmlstring .= $data;
  1449.             }
  1450.             return $xmlstring;
  1451.         }
  1452.         
  1453.         $this->success = 2;
  1454.         
  1455.         $xmlParser = $this->create_parser();
  1456.         
  1457.         // Process the file
  1458.         while( $data = fread( $fp, 4096 ) ) {
  1459.             if( !xml_parse( $xmlParser, $data, feof( $fp ) ) ) {
  1460.                 die( sprintf(
  1461.                     "XML error: %s at line %d",
  1462.                     xml_error_string( xml_get_error_code( $xmlParser) ),
  1463.                     xml_get_current_line_number( $xmlParser)
  1464.                 ) );
  1465.             }
  1466.         }
  1467.         
  1468.         xml_parser_free( $xmlParser );
  1469.         
  1470.         return $this->sqlArray;
  1471.     }
  1472.     
  1473.     /**
  1474.     * Converts an XML schema string to SQL.
  1475.     *
  1476.     * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
  1477.     * and generate the SQL necessary to create the database described by the schema. 
  1478.     * @see ParseSchema()
  1479.     *
  1480.     * @param string $xmlstring XML schema string.
  1481.     * @param bool $returnSchema Return schema rather than parsing.
  1482.     * @return array Array of SQL queries, ready to execute.
  1483.     */
  1484.     function ParseSchemaString( $xmlstring, $returnSchema = FALSE ) {
  1485.         if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
  1486.             return FALSE;
  1487.         }
  1488.         
  1489.         // do version detection here
  1490.         if( $this->SchemaStringVersion( $xmlstring ) != $this->schemaVersion ) {
  1491.             return FALSE;
  1492.         }
  1493.         
  1494.         if ( $returnSchema )
  1495.         {
  1496.             return $xmlstring;
  1497.         }
  1498.         
  1499.         $this->success = 2;
  1500.         
  1501.         $xmlParser = $this->create_parser();
  1502.         
  1503.         if( !xml_parse( $xmlParser, $xmlstring, TRUE ) ) {
  1504.             die( sprintf(
  1505.                 "XML error: %s at line %d",
  1506.                 xml_error_string( xml_get_error_code( $xmlParser) ),
  1507.                 xml_get_current_line_number( $xmlParser)
  1508.             ) );
  1509.         }
  1510.         
  1511.         xml_parser_free( $xmlParser );
  1512.         
  1513.         return $this->sqlArray;
  1514.     }
  1515.     
  1516.     /**
  1517.     * Loads an XML schema from a file and converts it to uninstallation SQL.
  1518.     *
  1519.     * Call this method to load the specified schema (see the DTD for the proper format) from
  1520.     * the filesystem and generate the SQL necessary to remove the database described.
  1521.     * @see RemoveSchemaString()
  1522.     *
  1523.     * @param string $file Name of XML schema file.
  1524.     * @param bool $returnSchema Return schema rather than parsing.
  1525.     * @return array Array of SQL queries, ready to execute
  1526.     */
  1527.     function RemoveSchema( $filename, $returnSchema = FALSE ) {
  1528.         return $this->RemoveSchemaString( $this->ConvertSchemaFile( $filename ), $returnSchema );
  1529.     }
  1530.     
  1531.     /**
  1532.     * Converts an XML schema string to uninstallation SQL.
  1533.     *
  1534.     * Call this method to parse a string containing an XML schema (see the DTD for the proper format)
  1535.     * and generate the SQL necessary to uninstall the database described by the schema. 
  1536.     * @see RemoveSchema()
  1537.     *
  1538.     * @param string $schema XML schema string.
  1539.     * @param bool $returnSchema Return schema rather than parsing.
  1540.     * @return array Array of SQL queries, ready to execute.
  1541.     */
  1542.     function RemoveSchemaString( $schema, $returnSchema = FALSE ) {
  1543.         
  1544.         // grab current version
  1545.         if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
  1546.             return FALSE;
  1547.         }
  1548.         
  1549.         return $this->ParseSchemaString( $this->TransformSchema( $schema, 'remove-' . $version), $returnSchema );
  1550.     }
  1551.     
  1552.     /**
  1553.     * Applies the current XML schema to the database (post execution).
  1554.     *
  1555.     * Call this method to apply the current schema (generally created by calling 
  1556.     * ParseSchema() or ParseSchemaString() ) to the database (creating the tables, indexes, 
  1557.     * and executing other SQL specified in the schema) after parsing.
  1558.     * @see ParseSchema(), ParseSchemaString(), ExecuteInline()
  1559.     *
  1560.     * @param array $sqlArray Array of SQL statements that will be applied rather than
  1561.     *        the current schema.
  1562.     * @param boolean $continueOnErr Continue to apply the schema even if an error occurs.
  1563.     * @returns integer 0 if failure, 1 if errors, 2 if successful.
  1564.     */
  1565.     function ExecuteSchema( $sqlArray = NULL, $continueOnErr =  NULL ) {
  1566.         if( !is_bool( $continueOnErr ) ) {
  1567.             $continueOnErr = $this->ContinueOnError();
  1568.         }
  1569.         
  1570.         if( !isset( $sqlArray ) ) {
  1571.             $sqlArray = $this->sqlArray;
  1572.         }
  1573.         
  1574.         if( !is_array( $sqlArray ) ) {
  1575.             $this->success = 0;
  1576.         } else {
  1577.             $this->success = $this->dict->ExecuteSQLArray( $sqlArray, $continueOnErr );
  1578.         }
  1579.         
  1580.         return $this->success;
  1581.     }
  1582.     
  1583.     /**
  1584.     * Returns the current SQL array. 
  1585.     *
  1586.     * Call this method to fetch the array of SQL queries resulting from 
  1587.     * ParseSchema() or ParseSchemaString(). 
  1588.     *
  1589.     * @param string $format Format: HTML, TEXT, or NONE (PHP array)
  1590.     * @return array Array of SQL statements or FALSE if an error occurs
  1591.     */
  1592.     function PrintSQL( $format = 'NONE' ) {
  1593.         $sqlArray = null;
  1594.         return $this->getSQL( $format, $sqlArray );
  1595.     }
  1596.     
  1597.     /**
  1598.     * Saves the current SQL array to the local filesystem as a list of SQL queries.
  1599.     *
  1600.     * Call this method to save the array of SQL queries (generally resulting from a
  1601.     * parsed XML schema) to the filesystem.
  1602.     *
  1603.     * @param string $filename Path and name where the file should be saved.
  1604.     * @return boolean TRUE if save is successful, else FALSE. 
  1605.     */
  1606.     function SaveSQL( $filename = './schema.sql' ) {
  1607.         
  1608.         if( !isset( $sqlArray ) ) {
  1609.             $sqlArray = $this->sqlArray;
  1610.         }
  1611.         if( !isset( $sqlArray ) ) {
  1612.             return FALSE;
  1613.         }
  1614.         
  1615.         $fp = fopen( $filename, "w" );
  1616.         
  1617.         foreach( $sqlArray as $key => $query ) {
  1618.             fwrite( $fp, $query . ";\n" );
  1619.         }
  1620.         fclose( $fp );
  1621.     }
  1622.     
  1623.     /**
  1624.     * Create an xml parser
  1625.     *
  1626.     * @return object PHP XML parser object
  1627.     *
  1628.     * @access private
  1629.     */
  1630.     function &create_parser() {
  1631.         // Create the parser
  1632.         $xmlParser = xml_parser_create();
  1633.         xml_set_object( $xmlParser, $this );
  1634.         
  1635.         // Initialize the XML callback functions
  1636.         xml_set_element_handler( $xmlParser, '_tag_open', '_tag_close' );
  1637.         xml_set_character_data_handler( $xmlParser, '_tag_cdata' );
  1638.         
  1639.         return $xmlParser;
  1640.     }
  1641.     
  1642.     /**
  1643.     * XML Callback to process start elements
  1644.     *
  1645.     * @access private
  1646.     */
  1647.     function _tag_open( &$parser, $tag, $attributes ) {
  1648.         switch( strtoupper( $tag ) ) {
  1649.             case 'TABLE':
  1650.                 $this->obj = new dbTable( $this, $attributes );
  1651.                 xml_set_object( $parser, $this->obj );
  1652.                 break;
  1653.             case 'SQL':
  1654.                 if( !isset( $attributes['PLATFORM'] ) OR $this->supportedPlatform( $attributes['PLATFORM'] ) ) {
  1655.                     $this->obj = new dbQuerySet( $this, $attributes );
  1656.                     xml_set_object( $parser, $this->obj );
  1657.                 }
  1658.                 break;
  1659.             default:
  1660.                 // print_r( array( $tag, $attributes ) );
  1661.         }
  1662.         
  1663.     }
  1664.     
  1665.     /**
  1666.     * XML Callback to process CDATA elements
  1667.     *
  1668.     * @access private
  1669.     */
  1670.     function _tag_cdata( &$parser, $cdata ) {
  1671.     }
  1672.     
  1673.     /**
  1674.     * XML Callback to process end elements
  1675.     *
  1676.     * @access private
  1677.     * @internal
  1678.     */
  1679.     function _tag_close( &$parser, $tag ) {
  1680.         
  1681.     }
  1682.     
  1683.     /**
  1684.     * Converts an XML schema string to the specified DTD version.
  1685.     *
  1686.     * Call this method to convert a string containing an XML schema to a different AXMLS
  1687.     * DTD version. For instance, to convert a schema created for an pre-1.0 version for 
  1688.     * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version 
  1689.     * parameter is specified, the schema will be converted to the current DTD version. 
  1690.     * If the newFile parameter is provided, the converted schema will be written to the specified
  1691.     * file.
  1692.     * @see ConvertSchemaFile()
  1693.     *
  1694.     * @param string $schema String containing XML schema that will be converted.
  1695.     * @param string $newVersion DTD version to convert to.
  1696.     * @param string $newFile File name of (converted) output file.
  1697.     * @return string Converted XML schema or FALSE if an error occurs.
  1698.     */
  1699.     function ConvertSchemaString( $schema, $newVersion = NULL, $newFile = NULL ) {
  1700.         
  1701.         // grab current version
  1702.         if( !( $version = $this->SchemaStringVersion( $schema ) ) ) {
  1703.             return FALSE;
  1704.         }
  1705.         
  1706.         if( !isset ($newVersion) ) {
  1707.             $newVersion = $this->schemaVersion;
  1708.         }
  1709.         
  1710.         if( $version == $newVersion ) {
  1711.             $result = $schema;
  1712.         } else {
  1713.             $result = $this->TransformSchema( $schema, 'convert-' . $version . '-' . $newVersion);
  1714.         }
  1715.         
  1716.         if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
  1717.             fwrite( $fp, $result );
  1718.             fclose( $fp );
  1719.         }
  1720.         
  1721.         return $result;
  1722.     }
  1723.     
  1724.     // compat for pre-4.3 - jlim
  1725.     function _file_get_contents($path)
  1726.     {
  1727.         if (function_exists('file_get_contents')) return file_get_contents($path);
  1728.         return join('',file($path));
  1729.     }
  1730.     
  1731.     /**
  1732.     * Converts an XML schema file to the specified DTD version.
  1733.     *
  1734.     * Call this method to convert the specified XML schema file to a different AXMLS
  1735.     * DTD version. For instance, to convert a schema created for an pre-1.0 version for 
  1736.     * AXMLS (DTD version 0.1) to a newer version of the DTD (e.g. 0.2). If no DTD version 
  1737.     * parameter is specified, the schema will be converted to the current DTD version. 
  1738.     * If the newFile parameter is provided, the converted schema will be written to the specified
  1739.     * file.
  1740.     * @see ConvertSchemaString()
  1741.     *
  1742.     * @param string $filename Name of XML schema file that will be converted.
  1743.     * @param string $newVersion DTD version to convert to.
  1744.     * @param string $newFile File name of (converted) output file.
  1745.     * @return string Converted XML schema or FALSE if an error occurs.
  1746.     */
  1747.     function ConvertSchemaFile( $filename, $newVersion = NULL, $newFile = NULL ) {
  1748.         
  1749.         // grab current version
  1750.         if( !( $version = $this->SchemaFileVersion( $filename ) ) ) {
  1751.             return FALSE;
  1752.         }
  1753.         
  1754.         if( !isset ($newVersion) ) {
  1755.             $newVersion = $this->schemaVersion;
  1756.         }
  1757.         
  1758.         if( $version == $newVersion ) {
  1759.             $result = _file_get_contents( $filename );
  1760.             
  1761.             // remove unicode BOM if present
  1762.             if( substr( $result, 0, 3 ) == sprintf( '%c%c%c', 239, 187, 191 ) ) {
  1763.                 $result = substr( $result, 3 );
  1764.             }
  1765.         } else {
  1766.             $result = $this->TransformSchema( $filename, 'convert-' . $version . '-' . $newVersion, 'file' );
  1767.         }
  1768.         
  1769.         if( is_string( $result ) AND is_string( $newFile ) AND ( $fp = fopen( $newFile, 'w' ) ) ) {
  1770.             fwrite( $fp, $result );
  1771.             fclose( $fp );
  1772.         }
  1773.         
  1774.         return $result;
  1775.     }
  1776.     
  1777.     function TransformSchema( $schema, $xsl, $schematype='string' )
  1778.     {
  1779.         // Fail if XSLT extension is not available
  1780.         if( ! function_exists( 'xslt_create' ) ) {
  1781.             return FALSE;
  1782.         }
  1783.         
  1784.         $xsl_file = dirname( __FILE__ ) . '/xsl/' . $xsl . '.xsl';
  1785.         
  1786.         // look for xsl
  1787.         if( !is_readable( $xsl_file ) ) {
  1788.             return FALSE;
  1789.         }
  1790.         
  1791.         switch( $schematype )
  1792.         {
  1793.             case 'file':
  1794.                 if( !is_readable( $schema ) ) {
  1795.                     return FALSE;
  1796.                 }
  1797.                 
  1798.                 $schema = _file_get_contents( $schema );
  1799.                 break;
  1800.             case 'string':
  1801.             default:
  1802.                 if( !is_string( $schema ) ) {
  1803.                     return FALSE;
  1804.                 }
  1805.         }
  1806.         
  1807.         $arguments = array (
  1808.             '/_xml' => $schema,
  1809.             '/_xsl' => _file_get_contents( $xsl_file )
  1810.         );
  1811.         
  1812.         // create an XSLT processor
  1813.         $xh = xslt_create ();
  1814.         
  1815.         // set error handler
  1816.         xslt_set_error_handler ($xh, array (&$this, 'xslt_error_handler'));
  1817.         
  1818.         // process the schema
  1819.         $result = xslt_process ($xh, 'arg:/_xml', 'arg:/_xsl', NULL, $arguments); 
  1820.         
  1821.         xslt_free ($xh);
  1822.         
  1823.         return $result;
  1824.     }
  1825.     
  1826.     /**
  1827.     * Processes XSLT transformation errors
  1828.     *
  1829.     * @param object $parser XML parser object
  1830.     * @param integer $errno Error number
  1831.     * @param integer $level Error level
  1832.     * @param array $fields Error information fields
  1833.     *
  1834.     * @access private
  1835.     */
  1836.     function xslt_error_handler( $parser, $errno, $level, $fields ) {
  1837.         if( is_array( $fields ) ) {
  1838.             $msg = array(
  1839.                 'Message Type' => ucfirst( $fields['msgtype'] ),
  1840.                 'Message Code' => $fields['code'],
  1841.                 'Message' => $fields['msg'],
  1842.                 'Error Number' => $errno,
  1843.                 'Level' => $level
  1844.             );
  1845.             
  1846.             switch( $fields['URI'] ) {
  1847.                 case 'arg:/_xml':
  1848.                     $msg['Input'] = 'XML';
  1849.                     break;
  1850.                 case 'arg:/_xsl':
  1851.                     $msg['Input'] = 'XSL';
  1852.                     break;
  1853.                 default:
  1854.                     $msg['Input'] = $fields['URI'];
  1855.             }
  1856.             
  1857.             $msg['Line'] = $fields['line'];
  1858.         } else {
  1859.             $msg = array(
  1860.                 'Message Type' => 'Error',
  1861.                 'Error Number' => $errno,
  1862.                 'Level' => $level,
  1863.                 'Fields' => var_export( $fields, TRUE )
  1864.             );
  1865.         }
  1866.         
  1867.         $error_details = $msg['Message Type'] . ' in XSLT Transformation' . "\n"
  1868.                        . '<table>' . "\n";
  1869.         
  1870.         foreach( $msg as $label => $details ) {
  1871.             $error_details .= '<tr><td><b>' . $label . ': </b></td><td>' . htmlentities( $details ) . '</td></tr>' . "\n";
  1872.         }
  1873.         
  1874.         $error_details .= '</table>';
  1875.         
  1876.         trigger_error( $error_details, E_USER_ERROR );
  1877.     }
  1878.     
  1879.     /**
  1880.     * Returns the AXMLS Schema Version of the requested XML schema file.
  1881.     *
  1882.     * Call this method to obtain the AXMLS DTD version of the requested XML schema file.
  1883.     * @see SchemaStringVersion()
  1884.     *
  1885.     * @param string $filename AXMLS schema file
  1886.     * @return string Schema version number or FALSE on error
  1887.     */
  1888.     function SchemaFileVersion( $filename ) {
  1889.         // Open the file
  1890.         if( !($fp = fopen( $filename, 'r' )) ) {
  1891.             // die( 'Unable to open file' );
  1892.             return FALSE;
  1893.         }
  1894.         
  1895.         // Process the file
  1896.         while( $data = fread( $fp, 4096 ) ) {
  1897.             if( preg_match( $this->versionRegex, $data, $matches ) ) {
  1898.                 return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
  1899.             }
  1900.         }
  1901.         
  1902.         return FALSE;
  1903.     }
  1904.     
  1905.     /**
  1906.     * Returns the AXMLS Schema Version of the provided XML schema string.
  1907.     *
  1908.     * Call this method to obtain the AXMLS DTD version of the provided XML schema string.
  1909.     * @see SchemaFileVersion()
  1910.     *
  1911.     * @param string $xmlstring XML schema string
  1912.     * @return string Schema version number or FALSE on error
  1913.     */
  1914.     function SchemaStringVersion( $xmlstring ) {
  1915.         if( !is_string( $xmlstring ) OR empty( $xmlstring ) ) {
  1916.             return FALSE;
  1917.         }
  1918.         
  1919.         if( preg_match( $this->versionRegex, $xmlstring, $matches ) ) {
  1920.             return !empty( $matches[2] ) ? $matches[2] : XMLS_DEFAULT_SCHEMA_VERSION;
  1921.         }
  1922.         
  1923.         return FALSE;
  1924.     }
  1925.     
  1926.     /**
  1927.     * Extracts an XML schema from an existing database.
  1928.     *
  1929.     * Call this method to create an XML schema string from an existing database.
  1930.     * If the data parameter is set to TRUE, AXMLS will include the data from the database
  1931.     * in the schema. 
  1932.     *
  1933.     * @param boolean $data Include data in schema dump
  1934.     * @return string Generated XML schema
  1935.     */
  1936.     function ExtractSchema( $data = FALSE ) {
  1937.         $old_mode = $this->db->SetFetchMode( ADODB_FETCH_NUM );
  1938.         
  1939.         $schema = '<?xml version="1.0"?>' . "\n"
  1940.                 . '<schema version="' . $this->schemaVersion . '">' . "\n";
  1941.         
  1942.         if( is_array( $tables = $this->db->MetaTables( 'TABLES' ) ) ) {
  1943.             foreach( $tables as $table ) {
  1944.                 $schema .= '    <table name="' . $table . '">' . "\n";
  1945.                 
  1946.                 // grab details from database
  1947.                 $rs = $this->db->Execute( 'SELECT * FROM ' . $table . ' WHERE 1=1' );
  1948.                 $fields = $this->db->MetaColumns( $table );
  1949.                 $indexes = $this->db->MetaIndexes( $table );
  1950.                 
  1951.                 if( is_array( $fields ) ) {
  1952.                     foreach( $fields as $details ) {
  1953.                         $extra = '';
  1954.                         $content = array();
  1955.                         
  1956.                         if( $details->max_length > 0 ) {
  1957.                             $extra .= ' size="' . $details->max_length . '"';
  1958.                         }
  1959.                         
  1960.                         if( $details->primary_key ) {
  1961.                             $content[] = '<KEY/>';
  1962.                         } elseif( $details->not_null ) {
  1963.                             $content[] = '<NOTNULL/>';
  1964.                         }
  1965.                         
  1966.                         if( $details->has_default ) {
  1967.                             $content[] = '<DEFAULT value="' . $details->default_value . '"/>';
  1968.                         }
  1969.                         
  1970.                         if( $details->auto_increment ) {
  1971.                             $content[] = '<AUTOINCREMENT/>';
  1972.                         }
  1973.                         
  1974.                         // this stops the creation of 'R' columns,
  1975.                         // AUTOINCREMENT is used to create auto columns
  1976.                         $details->primary_key = 0;
  1977.                         $type = $rs->MetaType( $details );
  1978.                         
  1979.                         $schema .= '        <field name="' . $details->name . '" type="' . $type . '"' . $extra . '>';
  1980.                         
  1981.                         if( !empty( $content ) ) {
  1982.                             $schema .= "\n            " . implode( "\n            ", $content ) . "\n        ";
  1983.                         }
  1984.                         
  1985.                         $schema .= '</field>' . "\n";
  1986.                     }
  1987.                 }
  1988.                 
  1989.                 if( is_array( $indexes ) ) {
  1990.                     foreach( $indexes as $index => $details ) {
  1991.                         $schema .= '        <index name="' . $index . '">' . "\n";
  1992.                         
  1993.                         if( $details['unique'] ) {
  1994.                             $schema .= '            <UNIQUE/>' . "\n";
  1995.                         }
  1996.                         
  1997.                         foreach( $details['columns'] as $column ) {
  1998.                             $schema .= '            <col>' . $column . '</col>' . "\n";
  1999.                         }
  2000.                         
  2001.                         $schema .= '        </index>' . "\n";
  2002.                     }
  2003.                 }
  2004.                 
  2005.                 if( $data ) {
  2006.                     $rs = $this->db->Execute( 'SELECT * FROM ' . $table );
  2007.                     
  2008.                     if( is_object( $rs ) ) {
  2009.                         $schema .= '        <data>' . "\n";
  2010.                         
  2011.                         while( $row = $rs->FetchRow() ) {
  2012.                             foreach( $row as $key => $val ) {
  2013.                                 $row[$key] = htmlentities($val);
  2014.                             }
  2015.                             
  2016.                             $schema .= '            <row><f>' . implode( '</f><f>', $row ) . '</f></row>' . "\n";
  2017.                         }
  2018.                         
  2019.                         $schema .= '        </data>' . "\n";
  2020.                     }
  2021.                 }
  2022.                 
  2023.                 $schema .= '    </table>' . "\n";
  2024.             }
  2025.         }
  2026.         
  2027.         $this->db->SetFetchMode( $old_mode );
  2028.         
  2029.         $schema .= '</schema>';
  2030.         return $schema;
  2031.     }
  2032.     
  2033.     /**
  2034.     * Sets a prefix for database objects
  2035.     *
  2036.     * Call this method to set a standard prefix that will be prepended to all database tables 
  2037.     * and indices when the schema is parsed. Calling setPrefix with no arguments clears the prefix.
  2038.     *
  2039.     * @param string $prefix Prefix that will be prepended.
  2040.     * @param boolean $underscore If TRUE, automatically append an underscore character to the prefix.
  2041.     * @return boolean TRUE if successful, else FALSE
  2042.     */
  2043.     function SetPrefix( $prefix = '', $underscore = TRUE ) {
  2044.         switch( TRUE ) {
  2045.             // clear prefix
  2046.             case empty( $prefix ):
  2047.                 logMsg( 'Cleared prefix' );
  2048.                 $this->objectPrefix = '';
  2049.                 return TRUE;
  2050.             // prefix too long
  2051.             case strlen( $prefix ) > XMLS_PREFIX_MAXLEN:
  2052.             // prefix contains invalid characters
  2053.             case !preg_match( '/^[a-z][a-z0-9_]+$/i', $prefix ):
  2054.                 logMsg( 'Invalid prefix: ' . $prefix );
  2055.                 return FALSE;
  2056.         }
  2057.         
  2058.         if( $underscore AND substr( $prefix, -1 ) != '_' ) {
  2059.             $prefix .= '_';
  2060.         }
  2061.         
  2062.         // prefix valid
  2063.         logMsg( 'Set prefix: ' . $prefix );
  2064.         $this->objectPrefix = $prefix;
  2065.         return TRUE;
  2066.     }
  2067.     
  2068.     /**
  2069.     * Returns an object name with the current prefix prepended.
  2070.     *
  2071.     * @param string    $name Name
  2072.     * @return string    Prefixed name
  2073.     *
  2074.     * @access private
  2075.     */
  2076.     function prefix( $name = '' ) {
  2077.         // if prefix is set
  2078.         if( !empty( $this->objectPrefix ) ) {
  2079.             // Prepend the object prefix to the table name
  2080.             // prepend after quote if used
  2081.             return preg_replace( '/^(`?)(.+)$/', '$1' . $this->objectPrefix . '$2', $name );
  2082.         }
  2083.         
  2084.         // No prefix set. Use name provided.
  2085.         return $name;
  2086.     }
  2087.     
  2088.     /**
  2089.     * Checks if element references a specific platform
  2090.     *
  2091.     * @param string $platform Requested platform
  2092.     * @returns boolean TRUE if platform check succeeds
  2093.     *
  2094.     * @access private
  2095.     */
  2096.     function supportedPlatform( $platform = NULL ) {
  2097.         $regex = '/^(\w*\|)*' . $this->db->databaseType . '(\|\w*)*$/';
  2098.         
  2099.         if( !isset( $platform ) OR preg_match( $regex, $platform ) ) {
  2100.             logMsg( "Platform $platform is supported" );
  2101.             return TRUE;
  2102.         } else {
  2103.             logMsg( "Platform $platform is NOT supported" );
  2104.             return FALSE;
  2105.         }
  2106.     }
  2107.     
  2108.     /**
  2109.     * Clears the array of generated SQL.
  2110.     *
  2111.     * @access private
  2112.     */
  2113.     function clearSQL() {
  2114.         $this->sqlArray = array();
  2115.     }
  2116.     
  2117.     /**
  2118.     * Adds SQL into the SQL array.
  2119.     *
  2120.     * @param mixed $sql SQL to Add
  2121.     * @return boolean TRUE if successful, else FALSE.
  2122.     *
  2123.     * @access private
  2124.     */    
  2125.     function addSQL( $sql = NULL ) {
  2126.         if( is_array( $sql ) ) {
  2127.             foreach( $sql as $line ) {
  2128.                 $this->addSQL( $line );
  2129.             }
  2130.             
  2131.             return TRUE;
  2132.         }
  2133.         
  2134.         if( is_string( $sql ) ) {
  2135.             $this->sqlArray[] = $sql;
  2136.             
  2137.             // if executeInline is enabled, and either no errors have occurred or continueOnError is enabled, execute SQL.
  2138.             if( $this->ExecuteInline() && ( $this->success == 2 || $this->ContinueOnError() ) ) {
  2139.                 $saved = $this->db->debug;
  2140.                 $this->db->debug = $this->debug;
  2141.                 $ok = $this->db->Execute( $sql );
  2142.                 $this->db->debug = $saved;
  2143.                 
  2144.                 if( !$ok ) {
  2145.                     if( $this->debug ) {
  2146.                         ADOConnection::outp( $this->db->ErrorMsg() );
  2147.                     }
  2148.                     
  2149.                     $this->success = 1;
  2150.                 }
  2151.             }
  2152.             
  2153.             return TRUE;
  2154.         }
  2155.         
  2156.         return FALSE;
  2157.     }
  2158.     
  2159.     /**
  2160.     * Gets the SQL array in the specified format.
  2161.     *
  2162.     * @param string $format Format
  2163.     * @return mixed SQL
  2164.     *    
  2165.     * @access private
  2166.     */
  2167.     function getSQL( $format = NULL, $sqlArray = NULL ) {
  2168.         if( !is_array( $sqlArray ) ) {
  2169.             $sqlArray = $this->sqlArray;
  2170.         }
  2171.         
  2172.         if( !is_array( $sqlArray ) ) {
  2173.             return FALSE;
  2174.         }
  2175.         
  2176.         switch( strtolower( $format ) ) {
  2177.             case 'string':
  2178.             case 'text':
  2179.                 return !empty( $sqlArray ) ? implode( ";\n\n", $sqlArray ) . ';' : '';
  2180.             case'html':
  2181.                 return !empty( $sqlArray ) ? nl2br( htmlentities( implode( ";\n\n", $sqlArray ) . ';' ) ) : '';
  2182.         }
  2183.         
  2184.         return $this->sqlArray;
  2185.     }
  2186.     
  2187.     /**
  2188.     * Destroys an adoSchema object.
  2189.     *
  2190.     * Call this method to clean up after an adoSchema object that is no longer in use.
  2191.     * @deprecated adoSchema now cleans up automatically.
  2192.     */
  2193.     function Destroy() {
  2194.         set_magic_quotes_runtime( $this->mgq );
  2195.         unset( $this );
  2196.     }
  2197. }
  2198.  
  2199. /**
  2200. * Message logging function
  2201. *
  2202. * @access private
  2203. */
  2204. function logMsg( $msg, $title = NULL, $force = FALSE ) {
  2205.     if( XMLS_DEBUG or $force ) {
  2206.         echo '<pre>';
  2207.         
  2208.         if( isset( $title ) ) {
  2209.             echo '<h3>' . htmlentities( $title ) . '</h3>';
  2210.         }
  2211.         
  2212.         if( is_object( $this ) ) {
  2213.             echo '[' . get_class( $this ) . '] ';
  2214.         }
  2215.         
  2216.         print_r( $msg );
  2217.         
  2218.         echo '</pre>';
  2219.     }
  2220. }
  2221. ?>